Что делает «use strict» в JavaScript и что за этим стоит?

Эта статья о строгом режиме Javascript может вас заинтересовать: Джон Ресиг - ECMAScript 5 Strict Mode, JSON и др.
Процитируем некоторые интересные части:
Строгий режим - это новая функция в ECMAScript 5, которая позволяет вам поместить программу или функцию в «строгий» рабочий контекст. Этот строгий контекст предотвращает выполнение определенных действий и вызывает больше исключений.
А также:
Строгий режим помогает по двум причинам:
Он отлавливает некоторые распространенные ляпы кодирования, выкидывая исключения.
Он предотвращает или вызывает ошибки, когда предпринимаются относительно "небезопасные" действия (например, получение доступа к глобальному объекту).
Он отключает функции, которые сбивают с толку или плохо продуманы.
Также обратите внимание, что вы можете применить «строгий режим» ко всему файлу ... Или вы можете использовать его только для определенной функции (все еще цитирую статью Джона Ресига):
// Нестрогий код ...
(функция () {
"использовать строго";
// Определите вашу библиотеку строго ...
}) ();
// Нестрогий код ...
Что может быть полезно, если вам нужно смешивать старый и новый код ;-)
Итак, я полагаю, это немного похоже на «use strict», которое вы можете использовать в Perl (отсюда и название?): Он помогает вам делать меньше ошибок, обнаруживая больше вещей, которые могут привести к поломкам.
Строгий режим теперь поддерживается всеми основными браузерами.
Внутри собственных модулей ECMAScript (с операторами импорта и экспорта) и классов ES6 строгий режим всегда включен и не может быть отключен.
|
Это новая функция ECMAScript 5. Джон Ресиг написал об этом хорошее резюме.
Это просто строка, которую вы вставляете в свои файлы JavaScript (либо в верхней части файла, либо внутри функции), которая выглядит следующим образом:
"использовать строго";
Включение его в код не должно вызывать проблем с текущими браузерами, поскольку это всего лишь строка. Это может вызвать проблемы с вашим кодом в будущем, если ваш код нарушает прагму. Например, если у вас сейчас есть foo = "bar" без определения foo, ваш код начнет давать сбой ... что, на мой взгляд, хорошо.
|
Заявление «используйте строгое»; указывает браузеру использовать строгий режим, который представляет собой сокращенный и более безопасный набор функций JavaScript.
Список функций (не исчерпывающий)
Запрещает глобальные переменные. (Обнаруживает отсутствующие объявления var и опечатки в именах переменных)
Незаметные неудачные назначения вызовут ошибку в строгом режиме (присвоение NaN = 5;)
Попытки удалить не подлежащие удалению свойства будут вызывать (удалить Object.prototype)
Требует, чтобы все имена свойств в литерале объекта были уникальными (var x = {x1: "1", x1: "2"})
Имена параметров функций должны быть уникальными (function sum (x, x) {...})
Запрещает восьмеричный синтаксис (var x = 023; некоторые разработчики ошибочно полагают, что предшествующий ноль никак не влияет на число.)
Запрещает ключевое слово with
eval в строгом режиме не вводит новые переменные
Запрещает удалять простые имена (удалить x;)
Запрещает привязку или присвоение имен eval и аргументов в любой форме
Строгий режим не связывает свойства объекта аргументов с формальными параметрами. (т.е. в функции sum (a, b) {return arguments [0] + b;} Это работает, потому что arguments [0] привязан к a и так далее.)
arguments.callee не поддерживается
[Ссылка: строгий режим, сеть разработчиков Mozilla]
|
Если люди беспокоятся об использовании use strict, возможно, стоит прочитать эту статью:
ECMAScript 5 Поддержка строгого режима в браузерах. Что это значит? NovoGeek.com - блог Кришны
В нем говорится о поддержке браузером, но, что более важно, о том, как с этим справиться:
function isStrictMode () {
вернуться! это;
}
/ *
возвращает false, поскольку this относится к глобальному объекту и
'! this' становится ложным
* /
function isStrictMode () {
"использовать строго";
вернуться! это;
}
/ *
возвращает true, так как в строгом режиме ключевое слово this
не относится к глобальному объекту, в отличие от традиционного JS.
Итак, здесь «это» является «неопределенным», а «! Это» становится правдой.
* /
|
Предупреждение, все вы, требовательные программисты: применение "строгого использования" к существующему коду может быть опасным! Это не какая-то наклейка со счастливым лицом, которую можно наклеить на код, чтобы сделать его «лучше». С помощью прагмы "use strict" браузер внезапно ВЫБРОСЫВАЕТ исключения в случайных местах, которые он никогда не выдавал раньше, только потому, что в этом месте вы делаете что-то, что по умолчанию / свободный JavaScript с радостью разрешает, но строгий JavaScript ненавидит! У вас могут быть нарушения строгости, скрывающиеся в редко используемых вызовах в вашем коде, которые выдают исключение только тогда, когда они в конечном итоге запускаются - скажем, в производственной среде, которую используют ваши платные клиенты!
Если вы собираетесь сделать решительный шаг, рекомендуется применить «use strict» вместе с комплексными модульными тестами и строго настроенной задачей сборки JSHint, которая даст вам некоторую уверенность в том, что нет темных уголков вашего модуля, которые взорвутся. ужасно просто потому, что вы включили строгий режим. Или, эй, вот еще один вариант: просто не добавляйте «use strict» ни в один из унаследованных кодов, честно говоря, это, вероятно, безопаснее. ОБЯЗАТЕЛЬНО НЕ ДОБАВЛЯЙТЕ "use strict" к модулям, которыми вы не владеете илиподдерживать, как сторонние модули.
Я думаю, что даже несмотря на то, что это смертельно опасное животное в клетке, "строгое использование" может быть хорошей вещью, но вы должны делать это правильно. Лучшее время для строгости - это когда ваш проект находится на начальном этапе, и вы начинаете с нуля. Сконфигурируйте JSHint / JSLint со всеми предупреждениями и параметрами, настроенными настолько жестко, насколько может ваша команда, получите хорошую систему сборки / тестирования / утверждения, подобную Grunt + Karma + Chai, и только ЗАТЕМ начните отмечать все свои новые модули как используйте строгий ". Будьте готовы исправить множество незначительных ошибок и предупреждений. Убедитесь, что все понимают важность, настроив сборку на FAIL, если JSHint / JSLint вызывает какие-либо нарушения.
Мой проект не был проектом с нуля, когда я принял «строгое использование». В результате моя IDE полна красных отметок, потому что у меня нет «строгого использования» для половины моих модулей, и JSHint жалуется на это. Это напоминание о том, каким рефакторингом мне следует заняться в будущем. Моя цель состоит в том, чтобы избавиться от красных отметок из-за всех моих пропущенных инструкций "use strict", но это уже через годы.
|
Использование 'use strict'; не делает ваш код внезапно лучше.
Строгий режим JavaScript - это функция ECMAScript 5. Вы можете включить строгий режим, объявив это в верхней части скрипта / функции.
'использовать строго';
Когда движок JavaScript видит эту директиву, он начинает интерпретировать код в специальном режиме. В этом режиме ошибки возникают при обнаружении определенных методов кодирования, которые могут оказаться потенциальными ошибками (что является причиной строгого режима).
Рассмотрим этот пример:
var a = 365;
var b = 030;
В своем стремлении выстроить числовые литералы в ряд, разработчик случайно инициализировал переменную b восьмеричным литералом. Нестрогий режим интерпретирует это как числовой литерал со значением 24 (по основанию 10). Однако строгий режим выдаст ошибку.
Неполный список специальностей в строгом режиме см. В этом ответе.
Где я должен использовать 'use strict' ;?
В моем новом приложении JavaScript: Абсолютно! Строгий режим можно использовать как информатор, когда вы делаете что-то глупое со своим кодом.
В моем существующем коде JavaScript: вероятно, нет! Если в вашем существующем коде JavaScript есть операторы, запрещенные в строгом режиме, приложение просто сломается. Если вам нужен строгий режим, вы должны быть готовы к отладке и исправлению существующего кода. Вот почему используется 'use strict'; не делает ваш код внезапно лучше.
Как использовать строгий режим?
Вставьте «использовать строгое»; заявление поверх вашего скрипта:
// Файл: myscript.js
'использовать строго';
var a = 2;
....
Обратите внимание, что все в файле myscript.js будет интерпретироваться в строгом режиме.
Или вставьте «строгое использование»; оператор поверх тела вашей функции:
function doSomething () {
'использовать строго';
...
}
Все, что находится в лексической области видимости функции doSomething, будет интерпретироваться в строгом режиме. Здесь важна лексическая область слова. Например, если ваш строгий код вызывает функцию библиотеки, которая не является строгой, в строгом режиме выполняется только ваш код, а не вызываемая функция. См. Этот ответ для лучшего объяснения.
Что запрещено в строгом режиме?
Я нашел хорошую статью, описывающую несколько вещей, которые запрещены в строгом режиме (обратите внимание, что это не эксклюзивный список):
Объем
Исторически сложилось так, что JavaScript не понимал, как функции
ограничены. Иногда они кажутся статическими, но некоторые
функции заставляют их вести себя так, как будто они имеют динамическую область видимости. Это
сбивает с толку, затрудняет чтение и понимание программ.
Непонимание вызывает ошибки. Это тоже проблема для производительности.
Статическая область видимости позволяет связывать переменную при компиляции
время, но требование динамической области означает, что привязка должна быть
отложено до времени выполнения, что обеспечивает значительную производительность
штраф.
Строгий режим требует, чтобы все привязки переменных выполнялись статически.
Это означает, что функции, которые ранее требовали динамической привязки
должны быть исключены или изменены. В частности, оператор with
устранены, а способность функции eval вмешиваться в
среда его вызывающего строго ограничена.
Одним из преимуществ строгого кода является то, что такие инструменты, как YUI Compressor
может лучше справиться с его обработкой.
Подразумеваемые глобальные переменные
JavaScript подразумевает глобальные переменные. Если
вы не объявляете переменную явно, глобальная переменная
неявно заявлено для вас. Это упрощает программирование для
новички, потому что они могут пренебречь некоторыми основными домашними делами
хлопоты. Но это делает управление крупными программами гораздо более сложным.
сложно, и это значительно снижает надежность. Так что в строгом
режиме подразумеваемые глобальные переменные больше не создаются. Вам следует
явно объявите все свои переменные.
Глобальная утечка
Есть ряд ситуаций, которые могут вызвать это
быть привязанным к глобальному объекту. Например, если вы забыли
предоставить новый префикс при вызове конструкторафункция,
конструктор this будет неожиданно привязан к глобальному объекту, поэтому
вместо инициализации нового объекта он будет молча
вмешательство в глобальные переменные. В этих ситуациях строгий режим будет
вместо этого привяжите это к undefined, что приведет к тому, что конструктор
вместо этого генерировать исключение, позволяя обнаружить ошибку
раньше.
Шумный отказ
JavaScript всегда имел свойства только для чтения, но вы
не мог создать их самостоятельно до тех пор, пока ES5 не получит Object.createProperty
функция раскрыла эту возможность. Если вы пытались присвоить значение
к свойству только для чтения, он потерпит неудачу без предупреждения. Задание будет
не изменять значение свойства, но ваша программа будет работать как
хотя это было. Это угроза целостности, из-за которой программы
перейти в противоречивое состояние. В строгом режиме попытка изменить
свойство только для чтения вызовет исключение.
Восьмеричный
Восьмеричное (или основание 8) представление чисел было чрезвычайно
полезно при программировании на уровне машины на машинах, слово которых
размеры были кратны 3. При работе с CDC вам требовалось восьмеричное число.
6600 мэйнфреймов с размером слова 60 бит. Если бы вы могли прочитать
восьмеричный, вы можете рассматривать слово как 20 цифр. Представлены две цифры
код операции, и одна цифра определяет один из 8 регистров. В течение
медленный переход от машинных кодов к языкам высокого уровня, это было
Считается полезным для предоставления восьмеричных форм в языках программирования.
В C крайне неудачное представление восьмеричности было
selected: ведущий ноль. Итак, в C 0100 означает 64, а не 100, а 08 - это
ошибка, а не 8. К большому сожалению, этот анахронизм был
скопировано почти на все современные языки, включая JavaScript, где
он используется только для создания ошибок. У него нет другой цели. Так что в
строгий режим, восьмеричные формы больше не допускаются.
И так далее
Псевдо-массив arguments становится немного больше
как массив в ES5. В строгом режиме теряется вызываемый и вызывающий
свойства. Это позволяет передавать ваши аргументы ненадежным
код, не отказываясь от конфиденциального контекста. Так же
свойство arguments функций исключено.
В строгом режиме повторяющиеся ключи в функциональном литерале будут создавать
синтаксическая ошибка. У функции не может быть двух параметров с одинаковым именем.
Функция не может иметь переменную с тем же именем, что и одна из ее
параметры. Функция не может удалять собственные переменные. Попытка
удаление не настраиваемого свойства теперь вызывает исключение. Примитивный
значения не переносятся неявно.
Зарезервированные слова для будущих версий JavaScript
ECMAScript 5 добавляет список зарезервированных слов. Если вы используете их как переменные или аргументы, строгий режим выдаст ошибку. Зарезервированные слова:
реализует, интерфейс, let, package, private, protected, public, static и yield
Дальнейшее чтение
Строгий режим - JavaScript | MDN
Поддержка браузером строгого режима
Переход в строгий режим
|
Я настоятельно рекомендую каждому разработчику начать использовать строгий режим прямо сейчас. Существует достаточно браузеров, поддерживающих его, поэтому строгий режим законно поможет спасти нас от ошибок, о которых мы даже не подозревали в вашем коде.
Судя по всему, на начальном этапе будут ошибки, с которыми мы раньше не сталкивались. Чтобы получить все преимущества, нам нужно провести надлежащее тестирование после переключения в строгий режим, чтобы убедиться, что мы все уловили. Определенно, мы не просто используем use strict в нашем коде и предполагаем, что ошибок нет. Итак, отток в том, что пора начать использовать эту невероятно полезную языковую функцию для написания лучшего кода.
Например,
var person = {
имя: 'xyz',
позиция: 'abc',
fullname: function () {"использовать строго"; вернуть this.name; }
};
JSLint - это отладчик, написанный Дугласом Крокфордом. Просто вставьте свой скрипт, и он быстро просканирует ваш код на наличие заметных проблем и ошибок.
|
Я хотел бы предложить несколько более обоснованный ответ, дополняющий другие ответы. Я надеялся отредактировать самый популярный ответ, но не смог. Я постарался сделать его настолько исчерпывающим и полным, насколько мог.
Вы можете обратиться к документации MDN для получения дополнительной информации.
"use strict" - директива, представленная в ECMAScript 5.
Директивы похожи на утверждения, но разные.
use strict не содержит ключевых слов: Директива - это простое выражение, которое состоит из специального строкового литерала (в одинарных или двойных кавычках). Механизмы JavaScript, которые не реализуют ECMAScript 5, просто видят выражение выражения без побочных эффектов. Ожидается, что в будущих версиях стандартов ECMAScript слово «употребление» станет ключевым словом; цитаты из-за этого устареют.
use strict может использоваться только в начале скрипта или функции, т.е. он должен предшествовать любому другому (реальному) оператору. Это не обязательно должна быть первая инструкция в скрипте функции: ей могут предшествовать другие выражения операторов, которые состоят из строковых литералов (и JavaScriptреализации могут рассматривать их как директивы, специфичные для реализации). Операторы строковых литералов, следующие за первым реальным оператором (в скрипте или функции), являются простыми операторами выражения. Переводчики не должны интерпретировать их как директивы, и они не имеют никакого эффекта.
Директива use strict указывает, что следующий код (в скрипте или функции) является строгим кодом.
Код на самом высоком уровне сценария (код, не входящий в функцию) считается строгим кодом, если сценарий содержит директиву use strict.
Содержимое функции считается строгим кодом, когда сама функция определена в строгом коде или когда функция содержит директиву use strict.
Код, который передается методу eval (), считается строгим кодом, если eval () был вызван из строгого кода или сам содержит директиву use strict.
Строгий режим ECMAScript 5 - это ограниченное подмножество языка JavaScript, которое устраняет соответствующие недостатки языка и обеспечивает более строгую проверку ошибок и более высокую безопасность. Ниже перечислены различия между строгим режимом и нормальным режимом (из которых первые три особенно важны):
Вы не можете использовать оператор with в строгом режиме.
В строгом режиме все переменные должны быть объявлены: если вы присвоите значение идентификатору, который не был объявлен как переменная, функция, параметр функции, параметр catch-clause или свойство глобального объекта, тогда вы получите ReferenceError. В нормальном режиме идентификатор неявно объявляется как глобальная переменная (как свойство глобального объекта)
В строгом режиме ключевое слово this имеет значение undefined в функциях, которые были вызваны как функции (а не как методы). (В нормальном режиме это всегда указывает на глобальный объект). Это различие можно использовать для проверки, поддерживает ли реализация строгий режим:
var hasStrictMode = (function () {"использовать строго"; вернуть это === undefined} ());
Также, когда функция вызывается с помощью call () или применяется в строгом режиме, это в точности значение первого аргумента вызова call () или apply (). (В нормальном режиме null и undefined заменяются глобальным Object, а значения, которые не являются объектами, преобразуются в объекты.)
В строгом режиме вы получите TypeError, когда попытаетесь назначить свойства только для чтения или определить новые свойства для нерасширяемого объекта. (В нормальном режиме оба просто выходят из строя без сообщения об ошибке.)
В строгом режиме при передаче кода в eval () вы не можете объявлять или определять переменные или функции в области действия вызывающего (как вы можете сделать это в обычном режиме). Вместо этого для eval () создается новая область видимости, в которой находятся переменные и функции. Эта область уничтожается после завершения выполнения eval ().
В строгом режиме объект-аргумент функции содержит статическую копию значений, которые передаются этой функции. В нормальном режиме объект-аргумент ведет себя несколько «волшебно»: элементы массива и параметры названной функции ссылаются на одно и то же значение.
В строгом режиме вы получите SyntaxError, когда за оператором удаления следует неквалифицированный идентификатор (переменная, функция или параметр функции). В нормальном режиме выражение удаления ничего не делает и оценивается как ложное.
В строгом режиме вы получите TypeError при попытке удалить не настраиваемое свойство. (В нормальном режиме попытка просто не удалась, и выражение удаления оценивается как ложное).
В строгом режиме считается синтаксической ошибкой, когда вы пытаетесь определить несколько свойств с одним и тем же именем для литерала объекта. (В нормальном режиме ошибки нет.)
В строгом режиме считается синтаксической ошибкой, когда объявление функции имеет несколько параметров с одинаковым именем. (В нормальном режиме ошибки нет.)
В строгом режиме восьмеричные литералы не допускаются (это литералы, начинающиеся с 0x. (В нормальном режиме некоторые реализации разрешают восьмеричные литералы).
В строгом режиме идентификаторы eval и аргументы обрабатываются как ключевые слова. Вы не можете изменить их значение, не можете присвоить им значение, и вы не можете использовать их в качестве имен для переменных, функций, параметров функций или идентификаторов блока catch.
В строгом режиме есть больше ограничений на возможности проверки стека вызовов. arguments.caller и arguments.callee вызывают ошибку TypeError в функции в строгом режиме. Более того, некоторые свойства вызывающего объекта и аргумента функций в строгом режиме вызывают ошибку TypeError при попытке их чтения.
|
Мои два цента:
Одна из целей строгого режима - обеспечить более быструю отладку проблем. Это помогает разработчикам, генерируя исключение, когда происходят определенные неправильные вещи, которые могут вызвать тихое и странное поведение вашей веб-страницы. В тот момент, когда мы используем use strict, код выдает ошибки, что помогает разработчику исправить их заранее.
Несколько важных вещей, которые я узнал после использования use strict:
Предотвращает объявление глобальной переменной:
var tree1Data= {имя: 'Банановое дерево', возраст: 100, количество листьев: 100000};
function Tree (typeOfTree) {
var age;
var leafCount;
age = typeOfTree.age;
leafCount = typeOfTree.leafCount;
nameoftree = typeOfTree.name;
};
var tree1 = новое дерево (tree1Data);
console.log (окно);
Теперь этот код создает nameoftree в глобальной области видимости, к которой можно получить доступ с помощью window.nameoftree. Когда мы реализуем use strict, код выдает ошибку.
Uncaught ReferenceError: nameoftree не определено
Образец
Устраняет с помощью утверждения:
Операторы with нельзя минимизировать с помощью таких инструментов, как uglify-js. Они также устарели и удалены из будущих версий JavaScript.
Образец
Предотвращает дублирование:
Когда у нас есть повторяющееся свойство, генерируется исключение
Uncaught SyntaxError: свойство повторяющихся данных в литерале объекта не
разрешено в строгом режиме
"использовать строго";
var tree1Data = {
название: 'Банановое дерево',
возраст: 100,
leafCount: 100000,
имя: 'Банановое дерево'
};
Их еще несколько, но мне нужно больше узнать об этом.
|
Если вы используете браузер, выпущенный примерно в прошлом году, он, скорее всего, поддерживает строгий режим JavaScript. Только старые браузеры до того, как ECMAScript 5 стал текущим стандартом, не поддерживают его.
Кавычки вокруг команды гарантируют, что код по-прежнему будет работать и в старых браузерах (хотя вещи, которые генерируют синтаксическую ошибку в строгом режиме, обычно просто вызывают сбои скрипта в некоторых трудно обнаруживаемых способах в старых браузерах).
|
При добавлении «use strict» в следующих случаях перед выполнением скрипта будет выдана ошибка SyntaxError:
Прокладывая путь для будущих версий ECMAScript, используя одно из недавно зарезервированных ключевых слов (в предвидении ECMAScript 6): реализации, interface, let, package, private, protected, public, static и yield.
Объявление функции в блоках
if (a : 3:15)
в <анонимный>: 6: 5
Здесь компилятор выдает ошибку ссылки. В строгом режиме компилятор не позволяет нам использовать переменную без ее объявления. Таким образом, утечки памяти можно предотвратить. Кроме того, мы можем написать более оптимизированный код.
|
Строгий режим устраняет ошибки, которые игнорировались бы в нестрогом режиме, тем самым делая javascript «более защищенным».
Считается ли это одним из лучших практик?
Да, включение строгого режима считается частью лучших практик при работе с javascript. Это делается путем добавления следующей строки кода в ваш JS файл.
'использовать строго';
в вашем коде.
Что это значит для пользовательских агентов?
Указание на то, что код должен интерпретироваться в строгом режиме, указывает для пользовательских агентов, таких как браузеры, что они должны обрабатывать код буквально как написано и выдавать ошибку, если код не имеет смысла.
Например: представьте, что в вашем файле .js есть следующий код:
Сценарий 1: [БЕЗ СТРОГОГО РЕЖИМА]
var city = "Чикаго"
console.log (city) // Выводит название города, например Чикаго
Сценарий 2: [БЕЗ СТРОГОГО РЕЖИМА]
city ​​= "Чикаго"
console.log (city) // Выводит название города, например Чикаго
Так почему же имя переменной печатается в обоих случаях?
Без включения строгого режима пользовательские агенты часто вносят ряд изменений в проблемный код, пытаясь придать ему смысл. На первый взгляд это может показаться прекрасной вещью, и действительно, работа за пределами строгого режима позволяет людям хорошо разбираться в коде JavaScript, не вдаваясь в детали. Однако как разработчик я не хочу оставлять ошибку в своем коде, потому что знаю, что она может вернуться и укусить меня позже, и я просто хочу написать хороший код. И тут выручает строгий режим.
Сценарий 3: [СТРОГОЙ РЕЖИМ]
'использовать строго';
city ​​= "Чикаго"
console.log (city) // Ошибка ссылки: присвоение не объявлено переменной city.
Дополнительный совет: чтобы поддерживать качество кода в строгом режиме, вам не нужно писать это снова и снова, особенно если у вас несколько файлов .js. Вы можете применить это правило глобально в правилах eslint следующим образом:
Имя файла: .eslintrc.js
module.exports = {
env: {
es6: правда
},
rules: {
строгий: ['ошибка', 'глобальный'],
},
};
Итак, что запрещено в строгом режиме?
Использование переменной без ее объявления вызовет ошибку в строгом режиме. Это сделано для предотвращения непреднамеренного создания глобальных переменных в вашем приложении. Пример с печатью Чикаго охватывает это, в частности.
Удаление переменной, функции или аргумента запрещено в строгом режиме.
"использовать строго";
функция x (p1, p2) {};
удалить x; // Это вызовет ошибку
Дублирование имени параметра не допускается в строгом режиме.
"использовать строго";
функция x (p1, p1) {}; // Это вызовет ошибку
Зарезервированные слова на языке Javascript не допускаются в строгом режиме. Слова - это интерфейс реализации, пусть, пакеты, частный, защищенный, общедоступный. статический и yield
Для более полного списка ознакомьтесь с документацией MDN здесь: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode
|
Весьма активный вопрос. Заработайте 10 репутации, чтобы ответить на этот вопрос. Требование репутации помогает защитить этот вопрос от спама и отсутствия ответов.
Не тот ответ, который вы ищете? Просмотрите другие вопросы с метками синтаксис javascript jslint use-strict или задайте свой вопрос.